function 点击坐标(x , y,sleeptime)
	-- 检查是否需要进行坐标转换
	if node_config and node_config.转换坐标 then
		x, y = node_config.转换坐标(x, y)
	end
	tap(x , y,sleeptime)
end

function 滑动坐标(x1 , y1 , x2 , y2 , swipetime)
	-- 检查是否需要进行坐标转换
	if node_config and node_config.转换坐标 then
		x1, y1 = node_config.转换坐标(x1, y1)
		x2, y2 = node_config.转换坐标(x2, y2)
	end
	swipe(x1 , y1 , x2 , y2 , swipetime)
	
end


function 获取屏幕分辨率()
    -- 尝试使用 getDisplaySize() 获取屏幕分辨率
    local width, height = getDisplaySize()
    if not width or not height then
        -- 如果获取失败，使用默认分辨率
        width, height = 720, 1280
        调试输出("无法获取屏幕分辨率，使用默认值: " .. width .. "x" .. height)
    else
        调试输出("获取到屏幕分辨率: " .. width .. "x" .. height)
        
        -- 自动设置节点配置的分辨率
        if node_config and node_config.设置分辨率 then
            node_config.设置分辨率(width, height)
        end
    end
    return width, height
end

function 计算滑动参数(屏幕宽度, 屏幕高度)
    -- 计算基础参数
    local 中心x = math.floor(屏幕宽度 * 0.5)
    local 安全边距 = math.floor(屏幕宽度 * 0.15)  -- 屏幕15%作为安全边距
    local 底部y = math.floor(屏幕高度 * 0.85)     -- 屏幕85%位置
    local 顶部y = math.floor(屏幕高度 * 0.15)     -- 屏幕15%位置
    
    -- 计算x轴随机范围
    local x轴随机范围 = math.floor(屏幕宽度 * 0.3)  -- 屏幕宽度的30%作为随机范围
    
    return {
        中心x = 中心x,
        安全边距 = 安全边距,
        底部y = 底部y,
        顶部y = 顶部y,
        x轴随机范围 = x轴随机范围
    }
end

-- 添加收藏和点赞节点定义
local 收藏按钮 = {0,0,0,0,{
    className = "android.widget.LinearLayout",
    packageName = "com.phoenix.read",
    id = "com.phoenix.read:id/bxj",
    bounds = {l=608,t=740,r=700,b=832}
}}

local 点赞按钮 = {0,0,0,0,{
    className = "android.widget.LinearLayout",
    packageName = "com.phoenix.read",
    id = "com.phoenix.read:id/d57",
    bounds = {l=608,t=901,r=700,b=1030}
}}

-- 根据ID查找节点并点击中心位置
function ID找节点(id, className, packageName, isClick)
    调试输出("尝试根据ID查找节点: " .. id)
    
    -- 设置默认值
    className = className or "android.widget.LinearLayout"
    packageName = packageName or "com.phoenix.read"
    
    -- 创建节点查询信息
    local 节点信息 = {className = className, packageName = packageName, id = id}
    
    -- 尝试查找节点
    local 节点 = nil
    local success, result = pcall(function()
        return nodeLib.findOne(节点信息)
    end)
    
    if not success then
        调试输出("查找节点出错: " .. tostring(result))
        return false
    end
    
    节点 = result
    
    -- 检查是否找到节点
    if 节点 == nil then
        调试输出("未找到ID为 " .. id .. " 的节点")
        return false
    end
    
    -- 获取bounds信息
    if 节点.bounds then
        调试输出("找到节点！位置信息: 左=" .. 节点.bounds.l .. " 上=" .. 节点.bounds.t .. 
                " 右=" .. 节点.bounds.r .. " 下=" .. 节点.bounds.b)
        
        -- 计算中心点
        local center_x = math.floor((节点.bounds.l + 节点.bounds.r) / 2)
        local center_y = math.floor((节点.bounds.t + 节点.bounds.b) / 2)
        
        调试输出("节点中心位置: x=" .. center_x .. ", y=" .. center_y)
        
        -- 如果需要点击，则点击中心位置
        if isClick then
            调试输出("点击节点中心")
            点击坐标(center_x, center_y, 1000)
            sleep(1000)
        end
        
        -- 返回节点和中心坐标
        return true, 节点, center_x, center_y
    else
        调试输出("节点没有bounds信息")
        return false
    end
end

-- ID查找并点击按钮列表
function ID列表查找按钮(id列表, className, packageName, isClick)
    if not id列表 or type(id列表) ~= "table" or #id列表 == 0 then
        调试输出("错误: ID列表为空或格式不正确")
        return false
    end
    
    -- 遍历ID列表，尝试每一个ID
    for i, id in ipairs(id列表) do
        调试输出("尝试查找ID: " .. id)
        
        local 成功, 节点, x, y = ID找节点(id, className, packageName, isClick)
        if 成功 then
            调试输出("成功找到并处理节点，使用ID: " .. id)
            return true, 节点, x, y
        end
    end
    
    调试输出("所有ID都未能找到对应节点")
    return false
end

-- 根据ID尝试查找点赞和收藏按钮
function 智能ID定位按钮()
    调试输出("开始智能ID定位按钮")
    
    -- 加载node_config
    local node_config = require("node_config")
    
    -- 尝试查找点赞按钮
    local 点赞成功 = false
    if node_config and node_config.可能的点赞按钮ID then
        调试输出("尝试定位点赞按钮")
        点赞成功, _, _, _ = ID列表查找按钮(node_config.可能的点赞按钮ID, 
                                    "android.widget.LinearLayout", 
                                    "com.phoenix.read", 
                                    true)
        if 点赞成功 then
            调试输出("点赞按钮点击成功")
            sleep(math.random(500, 1000))
        end
    end
    
    -- 尝试查找收藏按钮
    local 收藏成功 = false
    if node_config and node_config.可能的收藏按钮ID then
        调试输出("尝试定位收藏按钮")
        收藏成功, _, _, _ = ID列表查找按钮(node_config.可能的收藏按钮ID, 
                                    "android.widget.LinearLayout", 
                                    "com.phoenix.read", 
                                    true)
        if 收藏成功 then
            调试输出("收藏按钮点击成功")
            sleep(math.random(500, 1000))
        end
    end
    
    return 点赞成功 or 收藏成功
end

-- 修改随机收藏点赞函数，加入ID定位功能
function 随机收藏点赞()
    调试输出("开始执行随机收藏点赞")
    
    -- 设置概率阈值（66%概率点赞，66%概率收藏）
    local 点赞概率 = 66
    local 收藏概率 = 66
    
    -- 生成随机数 (1-100)
    local 随机数 = math.random(1, 100)
    
    -- 记录是否有操作
    local 有操作 = false
    
    -- 加载node_config
    local node_config = require("node_config")
    
    -- 检查是否触发点赞
    if 随机数 <= 点赞概率 then
        调试输出("触发点赞操作")
        
        -- 尝试使用节点方式点赞
        local 点赞成功 = false
        
        -- 尝试方法1：使用node_config中的点赞按钮配置
        if 中心找节点(node_config.点赞按钮, true) then
            调试输出("点赞成功 - 使用node_config中的节点")
            点赞成功 = true
            有操作 = true
            -- 点赞后短暂等待
            sleep(math.random(500, 1000))
        else
            调试输出("使用node_config中的点赞按钮失败，尝试其他方法")
        end
        
        -- 尝试方法2：使用ID列表查找按钮
        if not 点赞成功 and node_config.可能的点赞按钮ID then
            调试输出("尝试使用ID列表查找点赞按钮")
            local 成功, _, _, _ = ID列表查找按钮(node_config.可能的点赞按钮ID, 
                                         "android.widget.LinearLayout", 
                                         "com.phoenix.read", 
                                         true)
            if 成功 then
                调试输出("点赞成功 - 使用ID列表")
                点赞成功 = true
                有操作 = true
                sleep(math.random(500, 1000))
            end
        end
        
        -- 如果前两种方法都失败，使用自适应坐标点击
        if not 点赞成功 then
            调试输出("尝试使用自适应坐标点赞")
            
            -- 使用屏幕分辨率的相对坐标
            local 屏幕宽度, 屏幕高度 = 获取屏幕分辨率()
            local 点赞x = math.floor(屏幕宽度 * 0.85)
            local 点赞y = math.floor(屏幕高度 * 0.75)
            
            点击坐标(点赞x, 点赞y, 500)
            调试输出("点赞完成 - 使用自适应坐标")
            点赞成功 = true
            有操作 = true
            sleep(math.random(500, 1000))
        end
    end
    
    -- 生成新的随机数判断是否收藏
    随机数 = math.random(1, 100)
    if 随机数 <= 收藏概率 then
        调试输出("触发收藏操作")
        
        -- 尝试使用节点方式收藏
        local 收藏成功 = false
        
        -- 尝试方法1：使用node_config中的收藏按钮配置
        if 中心找节点(node_config.收藏按钮, true) then
            调试输出("收藏成功 - 使用node_config中的节点")
            收藏成功 = true
            有操作 = true
            -- 收藏后短暂等待
            sleep(math.random(500, 1000))
            -- 检查是否出现收藏意外弹窗
            检查收藏意外弹窗()
        else
            调试输出("使用node_config中的收藏按钮失败，尝试其他方法")
        end
        
        -- 尝试方法2：使用ID列表查找按钮
        if not 收藏成功 and node_config.可能的收藏按钮ID then
            调试输出("尝试使用ID列表查找收藏按钮")
            local 成功, _, _, _ = ID列表查找按钮(node_config.可能的收藏按钮ID, 
                                         "android.widget.LinearLayout", 
                                         "com.phoenix.read", 
                                         true)
            if 成功 then
                调试输出("收藏成功 - 使用ID列表")
                收藏成功 = true
                有操作 = true
                sleep(math.random(500, 1000))
                -- 检查是否出现收藏意外弹窗
                检查收藏意外弹窗()
            end
        end
        
        -- 如果前两种方法都失败，使用自适应坐标点击
        if not 收藏成功 then
            调试输出("尝试使用自适应坐标收藏")
            
            -- 使用屏幕分辨率的相对坐标
            local 屏幕宽度, 屏幕高度 = 获取屏幕分辨率()
            local 收藏x = math.floor(屏幕宽度 * 0.85)
            local 收藏y = math.floor(屏幕高度 * 0.65)
            
            点击坐标(收藏x, 收藏y, 500)
            调试输出("收藏完成 - 使用自适应坐标")
            收藏成功 = true
            有操作 = true
            sleep(math.random(500, 1000))
            -- 检查是否出现收藏意外弹窗
            检查收藏意外弹窗()
        end
    end
    
    -- 如果有操作，额外等待一段时间
    if 有操作 then
        local 额外等待 = math.random(800, 1500)
        调试输出("操作后等待: " .. 额外等待 .. "ms")
        sleep(额外等待)
    end
    
    return 有操作
end

-- 修改随机上滑函数，移除收藏点赞功能
function 随机上滑()
    -- 获取屏幕分辨率
    local 屏幕宽度, 屏幕高度 = 获取屏幕分辨率()
    local 参数 = 计算滑动参数(屏幕宽度, 屏幕高度)
    
    -- 原有的滑动逻辑保持不变
    local x起点 = 参数.中心x
    local x终点 = x起点 + math.random(-参数.x轴随机范围, 参数.x轴随机范围)
    local y起点 = 参数.底部y
    local y终点 = 参数.顶部y
    
    -- 添加随机偏移
    local x偏移范围 = math.floor(屏幕宽度 * 0.05)
    local y偏移范围 = math.floor(屏幕高度 * 0.05)
    
    x起点 = x起点 + math.random(-x偏移范围, x偏移范围)
    x终点 = x终点 + math.random(-x偏移范围, x偏移范围)
    y起点 = y起点 + math.random(-y偏移范围, y偏移范围)
    y终点 = y终点 + math.random(-y偏移范围, y偏移范围)
    
    -- 确保坐标在安全范围内
    x起点 = math.max(参数.安全边距, math.min(x起点, 屏幕宽度 - 参数.安全边距))
    x终点 = math.max(参数.安全边距, math.min(x终点, 屏幕宽度 - 参数.安全边距))
    y起点 = math.max(参数.顶部y, math.min(y起点, 参数.底部y))
    y终点 = math.max(参数.顶部y, math.min(y终点, 参数.底部y))
    
    -- 计算滑动时间
    local 基础滑动时间 = math.floor(屏幕高度 * 0.3)
    local 滑动时间 = math.random(基础滑动时间, 基础滑动时间 * 1.5)
    
    -- 调试信息简化
    调试输出("滑动中...")
    
    -- 执行滑动操作
    滑动坐标(x起点, y起点, x终点, y终点, 滑动时间)
    
    -- 滑动后停顿时间
    local 停顿时间 = math.random(800, 1200)
    sleep(停顿时间)
    
    return true
end

function 随机点击区域(x1 , y1 , x2 , y2)
	-- 在指定矩形区域内随机点击一个位置
	local random_x = math.random(x1 , x2)
	local random_y = math.random(y1 , y2)
	点击鼠标(random_x , random_y)
end

function 快速找图(x1 , y1 , x2 , y2 , pic_name , iisClick , delta_color , dir , sim)
	if delta_color == nil then
		delta_color = "101010"
		
	end
	if dir == nil then
		dir = 0
		
	end
	if sim == nil then
		sim = 0.9
		
	end
	
	local index , retList = findPicFast(x1 , y1 , x2 , y2 , pic_name , delta_color , dir , sim)
	
	if (index~= - 1)and(retList[1].x~= nil) then
		if isClick == true then
			点击坐标(retList[1].x , retList[1].y , 1000)
			
		end
		return true
	end
	return false
end

function 多点找色(arrColor , isClick)
	local x，y = findMultiColorT(arrColor)
	
	if x~= - 1 and y ~= - 1 then
		if isClick == true then
			点击坐标(x , y , 1000)
			
		end
		return true
		
	end
	return false
	
end


function 节点输入内容(nodeInfo , str)
	local node = nodeInfo:findOne(1)
	if node~= nil then
		node:setText(str)
		sleep(300)
		
	end
end

function 中心找节点(nodeArr, isClick)
    -- 检查nodeArr是否为nil或者不是表
    if nodeArr == nil or type(nodeArr) ~= "table" then
        print("错误: 节点信息为空或格式不正确")
        return false
    end
    
    -- 检查是否需要分辨率适配
    local 使用适配节点 = false
    local 原始节点名 = nil
    
    -- 如果是使用节点名而非直接节点信息，尝试进行分辨率适配
    if node_config and node_config.获取适配节点 and type(nodeArr) == "string" then
        原始节点名 = nodeArr
        nodeArr = node_config.获取适配节点(nodeArr)
        使用适配节点 = true
        
        -- 检查是否有分辨率特定调整
        if node_config.当前分辨率 and node_config.分辨率特定调整 and 
           node_config.分辨率特定调整[node_config.当前分辨率.宽度] and
           node_config.分辨率特定调整[node_config.当前分辨率.宽度][原始节点名] then
            -- 使用分辨率特定的节点定义
            nodeArr = node_config.分辨率特定调整[node_config.当前分辨率.宽度][原始节点名]
            print("使用" .. node_config.当前分辨率.宽度 .. "分辨率特定的节点定义: " .. 原始节点名)
        end
    end
    
    -- 检查nodeArr[5]是否存在
    if nodeArr[5] == nil then
        print("错误: 节点信息不完整，缺少第5个元素")
        return false
    end
    
    -- 输出节点信息以帮助调试
    print("尝试查找节点: " .. tostring(nodeArr[5].className or nodeArr[5].class) .. 
          ", ID: " .. tostring(nodeArr[5].id))
    
    local ret = nil
    -- 使用pcall包装可能出错的调用
    local success, result = pcall(function()
        -- 尝试方法1：使用五个参数
        local node = nodeLib.findOne(nodeArr[1], nodeArr[2], nodeArr[3], nodeArr[4], nodeArr[5])
        if node then return node end
        
        -- 如果失败，尝试方法2：直接传递第5个元素
        return nodeLib.findOne(nodeArr[5])
    end)
    
    if not success then
        print("查找节点时出错: " .. tostring(result))
        return false
    end
    
    ret = result
    
    if ret ~= nil then
        -- 添加更详细的打印信息
        print("找到节点！位置：")
        print("左："..ret.bounds.l.." 上："..ret.bounds.t)
        print("右："..ret.bounds.r.." 下："..ret.bounds.b)
        if isClick == true then
            local center_x = (ret.bounds.l + ret.bounds.r)/2
            local center_y = (ret.bounds.t + ret.bounds.b)/2
            print("点击位置：x="..center_x..", y="..center_y)
            点击坐标(center_x, center_y, 1000)
            sleep(1000)
        end
        return true
    end
    print("未找到节点")
    return false
end

function 方框找节点(节点信息, isClick)
    -- 检查节点信息是否为nil
    if 节点信息 == nil then
        print("错误: 节点信息为空")
        return false
    end
    
    -- 检查是否需要分辨率适配
    local 使用适配节点 = false
    local 原始节点名 = nil
    
    -- 如果是使用节点名而非直接节点信息，尝试进行分辨率适配
    if node_config and node_config.获取适配节点 and type(节点信息) == "string" then
        原始节点名 = 节点信息
        节点信息 = node_config.获取适配节点(节点信息)
        使用适配节点 = true
        
        -- 检查是否有分辨率特定调整
        if node_config.当前分辨率 and node_config.分辨率特定调整 and 
           node_config.分辨率特定调整[node_config.当前分辨率.宽度] and
           node_config.分辨率特定调整[node_config.当前分辨率.宽度][原始节点名] then
            -- 使用分辨率特定的节点定义
            节点信息 = node_config.分辨率特定调整[node_config.当前分辨率.宽度][原始节点名]
            print("使用" .. node_config.当前分辨率.宽度 .. "分辨率特定的节点定义: " .. 原始节点名)
        end
    end
    
    local ret = nil
    local success, result = pcall(function()
        -- 如果是数组格式，取第5个元素
        if type(节点信息) == "table" and 节点信息[5] then
            return nodeLib.findOne(节点信息[5])
        else
            -- 如果不是数组格式，直接使用
            return nodeLib.findOne(节点信息)
        end
    end)
    
    if not success then
        print("查找节点时出错: " .. tostring(result))
        return false
    end
    
    ret = result
    
    if ret then
        print("找到节点！位置：")
        print("左："..ret.bounds.l.." 上："..ret.bounds.t)
        print("右："..ret.bounds.r.." 下："..ret.bounds.b)
        if isClick then
            local x = (ret.bounds.l + ret.bounds.r)/2
            local y = (ret.bounds.t + ret.bounds.b)/2
            print("点击位置：x="..x..", y="..y)
            点击坐标(x, y, 10)
            sleep(10)
        end
        return true
    end
    print("未找到节点")
    return false
end


function 调试输出(内容, sleepTime)
    -- 保持原来的功能，支持旧代码
    if sleepTime == nil then
        sleepTime = 1000
    end
    
    -- 输出到控制台
    print(内容)
    
    -- 如果HUD已初始化，则使用HUD系统
    if HUD and HUD.id and HUD.isActive then
        添加日志(内容, "调试")
    end
    
    sleep(sleepTime)
    
    return 内容
end

-- 添加全局变量用于时间控制
local 开始时间 = 0
local 上次福利时间 = 0

function 初始化时间()
    开始时间 = os.time()
    上次福利时间 = 开始时间
end

function 检查福利时间()
    local 当前时间 = os.time()
    local 距离上次福利 = 当前时间 - 上次福利时间
    
    -- 如果距离上次点击福利超过30分钟
    if 距离上次福利 >= 1800 then  -- 1800秒 = 30分钟
        上次福利时间 = 当前时间
        return true
    end
    return false
end

function 获取运行时间()
    local 当前时间 = os.time()
    return 当前时间 - 开始时间
end

function 处理福利界面()
    调试输出("进入福利界面处理")
    
    -- 点击福利按钮
    if 中心找节点(node_config.福利按钮, true) then
        sleep(2000)  -- 等待福利界面加载
        
        -- 在福利界面进行操作
        for i = 1, 3 do  -- 尝试3次
            -- 查找并点击可领取的福利
            if 中心找节点(node_config.可领取福利, true) then
                调试输出("领取福利成功")
                sleep(1000)
            else
                调试输出("没有可领取的福利")
                break
            end
        end
        
        -- 返回主界面
        if 中心找节点(node_config.返回按钮, true) then
            调试输出("返回主界面")
            sleep(2000)
        end
        
        return true
    else
        调试输出("未找到福利按钮")
        return false
    end
end

-- HUD日志系统
HUD = {
    id = nil,             -- HUD的ID
    isActive = false,     -- HUD是否显示
    logBuffer = {},       -- 日志缓冲区
    maxLogs = 5,          -- 显示的最大日志数量
    defaultFontSize = 10, -- 默认字体大小
    fontColor = "0xffff0000", -- 默认字体颜色
    bgColor = "0x60ffffff",   -- 背景颜色（更透明）
    xPos = 0,             -- X位置
    yPos = 80,            -- Y位置
    width = 500,          -- HUD宽度（缩小）
    height = 22,          -- 单行高度（缩小）
    -- 格式化日志模板
    日志格式 = "{时间} {内容}"  -- 默认格式，移除级别显示
}

-- 初始化HUD系统
function 初始化HUD系统(配置)
    -- 确保HUD表存在
    if HUD == nil then
        print("警告: HUD表未定义，将重新创建")
        HUD = {
            id = nil,             -- HUD的ID
            isActive = false,     -- HUD是否显示
            logBuffer = {},       -- 日志缓冲区
            maxLogs = 5,          -- 显示的最大日志数量
            defaultFontSize = 10, -- 默认字体大小
            fontColor = "0xffff0000", -- 默认字体颜色
            bgColor = "0x60ffffff",   -- 背景颜色（更透明）
            xPos = 0,             -- X位置
            yPos = 80,            -- Y位置
            width = 500,          -- HUD宽度（缩小）
            height = 22,          -- 单行高度（缩小）
            -- 格式化日志模板
            日志格式 = "{时间} {内容}"  -- 默认格式，移除级别显示
        }
    end
    
    -- 尝试从UI配置加载HUD设置
    local 加载UI配置 = false
    pcall(function()
        if _G.获取HUD配置 and type(_G.获取HUD配置) == "function" then
            local ui配置 = _G.获取HUD配置()
            if ui配置 and type(ui配置) == "table" then
                配置 = 配置 or {}
                
                -- 如果UI配置中禁用了HUD，则直接返回
                if ui配置.启用HUD == false then
                    print("UI配置已禁用HUD显示")
                    HUD.isActive = false
                    return
                end
                
                -- 合并UI配置到当前配置
                配置.最大日志数 = 配置.最大日志数 or ui配置.最大日志数
                配置.字体大小 = 配置.字体大小 or ui配置.字体大小
                配置.字体颜色 = 配置.字体颜色 or ui配置.字体颜色
                配置.背景颜色 = 配置.背景颜色 or ui配置.背景颜色
                配置.X位置 = 配置.X位置 or ui配置.X位置
                配置.Y位置 = 配置.Y位置 or ui配置.Y位置
                配置.宽度 = 配置.宽度 or ui配置.宽度
                配置.高度 = 配置.高度 or ui配置.高度
                
                -- 应用日志格式
                if ui配置.日志格式 and ui配置.日志格式 ~= "" then
                    HUD.日志格式 = ui配置.日志格式
                end
                
                加载UI配置 = true
                print("已从UI加载HUD配置")
            end
        end
    end)
    
    if not 加载UI配置 then
        print("使用默认或传入的HUD配置")
    end
    
    配置 = 配置 or {}
    
    -- 使用pcall保护可能出错的代码
    local success, result = pcall(function()
        -- 应用配置
        HUD.maxLogs = 配置.最大日志数 or HUD.maxLogs
        HUD.defaultFontSize = 配置.字体大小 or HUD.defaultFontSize
        HUD.fontColor = 配置.字体颜色 or HUD.fontColor
        HUD.bgColor = 配置.背景颜色 or HUD.bgColor
        HUD.xPos = 配置.X位置 or HUD.xPos
        HUD.yPos = 配置.Y位置 or HUD.yPos
        HUD.width = 配置.宽度 or HUD.width
        HUD.height = 配置.高度 or HUD.height
        
        -- 如果已有HUD，先销毁
        if HUD.id then
            hideHUD(HUD.id)
            print("已销毁现有HUD，ID:" .. HUD.id)
        end
        
        -- 创建新HUD
        HUD.id = createHUD()
        HUD.isActive = true
        HUD.logBuffer = {}
        
        -- 返回ID
        return HUD.id
    end)
    
    if not success then
        print("初始化HUD系统出错: " .. tostring(result))
        -- 尝试创建一个简单的HUD作为备用
        pcall(function()
            if not HUD.id then
                HUD.id = createHUD()
                HUD.isActive = true
                showHUD(HUD.id, "HUD系统初始化失败，使用备用显示", 10, "0xffff0000", "0x60ffffff", 0, 80, 0, 500, 22)
            end
        end)
        return HUD.id
    else
        print("HUD系统已初始化，ID:" .. tostring(result))
        return result
    end
end

-- 设置日志格式
function 设置日志格式(格式)
    if type(格式) == "string" then
        HUD.日志格式 = 格式
        调试输出("日志格式已更新")
    end
end

-- 添加日志并更新HUD显示
function 添加日志(内容, 级别)
    级别 = 级别 or "信息"
    local 时间标记 = os.date("%H:%M:%S")
    
    -- 使用模板格式化日志
    local 格式化日志 = HUD.日志格式
    格式化日志 = 格式化日志:gsub("{时间}", 时间标记)
    格式化日志 = 格式化日志:gsub("{级别}", 级别)
    格式化日志 = 格式化日志:gsub("{内容}", 内容)
    
    -- 添加到缓冲区
    table.insert(HUD.logBuffer, 1, 格式化日志) -- 新日志插入到开头
    
    -- 保持缓冲区大小
    while #HUD.logBuffer > HUD.maxLogs do
        table.remove(HUD.logBuffer) -- 移除最老的日志
    end
    
    -- 更新控制台输出（直接使用print，避免递归调用）
    print(格式化日志)
    
    -- 更新HUD显示
    更新HUD显示()
    
    return 格式化日志
end

-- 调试日志（原调试输出的替代函数）
function 调试输出(内容)
    return 添加日志(内容, "调试")
end

-- 错误日志
function 错误日志(内容)
    -- 直接添加日志而不通过调试输出，避免递归
    return 添加日志(内容, "错误")
end

-- 警告日志
function 警告日志(内容)
    -- 直接添加日志而不通过调试输出，避免递归
    return 添加日志(内容, "警告")
end

-- 状态信息（固定显示在HUD最上方，不会滚动）
HUD.状态信息 = nil

-- 设置状态信息（固定显示在HUD顶部）
function 设置状态信息(信息)
    HUD.状态信息 = 信息
    更新HUD显示()
end

-- 清除状态信息
function 清除状态信息()
    HUD.状态信息 = nil
    更新HUD显示()
end

-- 显示进度条
function 显示进度(当前值, 总值, 说明文本)
    当前值 = tonumber(当前值) or 0
    总值 = tonumber(总值) or 100
    说明文本 = 说明文本 or ""
    
    -- 确保范围在0-100%
    local 百分比 = math.min(100, math.max(0, (当前值 / 总值) * 100))
    
    -- 创建进度条字符串
    local 进度条长度 = 15  -- 缩短进度条长度
    local 已完成数量 = math.floor((百分比 / 100) * 进度条长度)
    local 进度条 = string.rep("█", 已完成数量) .. string.rep("░", 进度条长度 - 已完成数量)
    
    -- 格式化信息，更紧凑
    local 进度信息 = string.format("%s %s %.0f%%", 说明文本, 进度条, 百分比)
    
    -- 设置为状态信息
    设置状态信息(进度信息)
    
    return 进度信息
end

-- 更新HUD显示
function 更新HUD显示()
    -- 先检查HUD是否可用
    if not HUD是否可用() then return end
    
    -- 使用pcall保护可能出错的代码
    local success, err = pcall(function()
        -- 准备显示内容
        local 显示文本列表 = {}
        
        -- 如果有状态信息，放在最上方
        if HUD.状态信息 then
            table.insert(显示文本列表, HUD.状态信息)
            -- 添加分隔行
            table.insert(显示文本列表, string.rep("-", 40))
        end
        
        -- 添加常规日志内容
        for _, 日志 in ipairs(HUD.logBuffer or {}) do
            table.insert(显示文本列表, 日志)
        end
        
        -- 合并所有文本
        local 显示文本 = table.concat(显示文本列表, "\n")
        
        -- 计算显示行数
        local 显示行数 = #显示文本列表
        
        -- 计算总高度（每行高度 * 行数）
        local 总高度 = HUD.height * 显示行数
        
        -- 显示HUD内容
        showHUD(
            HUD.id, 
            显示文本, 
            HUD.defaultFontSize, 
            HUD.fontColor, 
            HUD.bgColor, 
            HUD.xPos, 
            HUD.yPos, 
            0, 
            HUD.width, 
            总高度
        )
    end)
    
    if not success then
        print("更新HUD显示时出错: " .. tostring(err))
    end
end

-- 显示或隐藏HUD
function 切换HUD显示(显示)
    if 显示 == nil then
        HUD.isActive = not HUD.isActive
    else
        HUD.isActive = 显示
    end
    
    if HUD.isActive then
        更新HUD显示()
    else
        hideHUD(HUD.id)
    end
    
    return HUD.isActive
end

-- 清空日志
function 清空日志()
    HUD.logBuffer = {}
    更新HUD显示()
end

-- 销毁HUD
function 销毁HUD()
    -- 使用pcall保护避免错误
    pcall(function()
        if HUD and HUD.id then
            hideHUD(HUD.id)
            HUD.id = nil
            HUD.isActive = false
            HUD.logBuffer = {}
            print("HUD系统已销毁")
        end
    end)
end

-- 安全检查HUD是否可用
function HUD是否可用()
    return HUD ~= nil and HUD.id ~= nil and HUD.isActive == true
end

-- HUD预览函数
function 预览HUD配置(配置)
    配置 = 配置 or {}
    
    -- 保存当前HUD状态
    local 旧ID = HUD.id
    local 旧状态 = HUD.isActive
    local 旧日志 = HUD.logBuffer
    
    -- 临时关闭现有HUD
    if HUD.id then
        hideHUD(HUD.id)
    end
    
    -- 初始化临时HUD
    local id = 初始化HUD系统(配置)
    
    -- 显示预览信息
    调试输出("HUD预览效果", 0)
    调试输出("这是一条日志消息", 0)
    调试输出("宽度: " .. HUD.width .. ", 高度: " .. HUD.height, 0)
    调试输出("位置: X=" .. HUD.xPos .. ", Y=" .. HUD.yPos, 0)
    调试输出("字体大小: " .. HUD.defaultFontSize, 0)
    
    -- 显示进度条示例
    显示进度(60, 100, "进度演示")
    
    -- 等待用户查看
    sleep(5000)
    
    -- 恢复原始HUD
    hideHUD(HUD.id)
    HUD.id = 旧ID
    HUD.isActive = 旧状态
    HUD.logBuffer = 旧日志
    
    if 旧ID and 旧状态 then
        更新HUD显示()
    end
    
    return true
end

-- 应用HUD配置函数
function 应用HUD配置(配置)
    配置 = 配置 or {}
    
    -- 初始化新的HUD
    初始化HUD系统(配置)
    
    -- 提示已应用配置
    调试输出("已应用HUD配置", 0)
    
    return true
end

-- 重置HUD配置
function 重置HUD配置()
    -- 恢复默认配置
    HUD = {
        id = nil,             -- HUD的ID
        isActive = false,     -- HUD是否显示
        logBuffer = {},       -- 日志缓冲区
        maxLogs = 6,          -- 显示的最大日志数量
        defaultFontSize = 10, -- 默认字体大小
        fontColor = "0xffff0000", -- 默认字体颜色
        bgColor = "0x60ffffff",   -- 背景颜色（更透明）
        xPos = 0,             -- X位置
        yPos = 80,            -- Y位置
        width = 500,          -- HUD宽度（缩小）
        height = 22,          -- 单行高度（缩小）
        -- 格式化日志模板
        日志格式 = "{时间} {内容}"  -- 默认格式，移除级别显示
    }
    
    -- 重新初始化HUD
    初始化HUD系统()
    
    -- 提示已重置配置
    调试输出("已重置HUD配置为默认值", 0)
    
    return true
end

-- 中心发现节点：只检查节点是否存在，不执行点击操作
function 中心发现节点(nodeArr)
    -- 检查nodeArr是否为nil或者不是表
    if nodeArr == nil or type(nodeArr) ~= "table" then
        print("错误: 节点信息为空或格式不正确")
        return false
    end
    
    -- 检查nodeArr[5]是否存在
    if nodeArr[5] == nil then
        print("错误: 节点信息不完整，缺少第5个元素")
        return false
    end
    
    -- 输出查找信息
    print("尝试查找节点: " .. tostring(nodeArr[5].className or nodeArr[5].class) .. 
          ", 文本: " .. tostring(nodeArr[5].text))
    
    local ret = nil
    -- 使用pcall包装可能出错的调用
    local success, result = pcall(function()
        -- 尝试方法1：使用五个参数
        local node = nodeLib.findOne(nodeArr[1], nodeArr[2], nodeArr[3], nodeArr[4], nodeArr[5])
        if node then return node end
        
        -- 如果失败，尝试方法2：直接传递第5个元素
        return nodeLib.findOne(nodeArr[5])
    end)
    
    if not success then
        print("查找节点时出错: " .. tostring(result))
        return false
    end
    
    ret = result
    
    if ret ~= nil then
        -- 节点找到，添加简单的打印信息
        print("找到节点！位置：左=" .. ret.bounds.l .. ", 上=" .. ret.bounds.t ..
              ", 右=" .. ret.bounds.r .. ", 下=" .. ret.bounds.b)
        return true
    end
    
    print("未找到节点")
    return false
end

-- 检查APP是否已启动并进入界面
function 检查APP已启动(检查节点)
    -- 默认使用首页选项卡作为判断依据
    if 检查节点 == nil then
        local node_config = require("node_config")
        检查节点 = node_config.首页选项卡
    end
    
    -- 尝试查找节点
    local 已进入APP = 中心发现节点(检查节点)
    
    if 已进入APP then
        print("已检测到APP界面，无需等待")
        return true
    else
        print("未检测到APP界面")
        return false
    end
end

-- 检查收藏意外弹窗并处理
function 检查收藏意外弹窗()
    -- 加载节点配置
    local node_config = require("node_config")
    
    -- 给系统一点时间显示弹窗
    sleep(800)
    
    -- 检查是否出现取消按钮
    if 中心发现节点(node_config.取消按钮) then
        调试输出("检测到收藏意外弹窗，点击取消")
        中心找节点(node_config.取消按钮, true)
        sleep(1000)  -- 等待弹窗消失
        return true
    end
    
    return false
end

-- 模拟按键函数（替代keypress）
function 模拟按键(keyCode)
    -- 检查是否有pressKey函数
    if pressKey then
        pressKey(keyCode)
        return true
    end
    
    -- 检查是否有press函数
    if press then
        press(keyCode)
        return true
    end
    
    -- 如果都没有，尝试用tap点击屏幕边缘来模拟返回（仅适用于返回键）
    if keyCode == 4 then -- Android返回键代码
        local width, height = 获取屏幕分辨率()
        -- 点击屏幕左侧中部，这在很多应用中相当于返回操作
        tap(10, height/2, 100)
        调试输出("使用屏幕点击模拟返回键")
        return true
    end
    
    调试输出("警告: 无法模拟按键，缺少相关函数")
    return false
end

-- 检测是否已进入视频播放界面（通过倍速节点判断）
function 检查视频界面()
    -- 加载节点配置
    local node_config = require("node_config")
    
    -- 尝试查找倍速节点
    local 已进入视频界面 = 中心发现节点(node_config.倍速节点)
    
    if 已进入视频界面 then
        调试输出("已检测到视频播放界面（找到倍速节点）")
        return true
    else
        调试输出("未检测到视频播放界面")
        return false
    end
end